//可以写入
#include "application.h"
#include <iostream>
using namespace std;

//board
int maze[8][8] = {
	{0, 0, 0, 0, 0, 0, 0, 0} ,
	{0, 0, 0, 0, 0, 0, 0, 0} ,
	{0, 0, 0, 0, 0, 0, 0, 0} ,
	{0, 0, 0, 0, 0, 0, 0, 0} ,
	{0, 0, 0, 0, 0, 0, 0, 0} ,
	{0, 0, 0, 0, 0, 0, 0, 0} ,
	{0, 0, 0, 0, 0, 0, 0, 0} ,
	{0, 0, 0, 0, 0, 0, 0, 0} 
};

void Application::initialize() {}

Position Application::getStartPosition()
{
	return Position(0, 0);
}
	
// 检查在位置p放置皇后是否安全
bool Application::isValid(const Position& p)
{
	int row = p.getRow();
	int column = p.getColumn();
    
    // 检查同一列是否有皇后
    for (int i = 0; i < row; i++) {
        if (maze[i][column] == 8) {
            return false;
        }
    }
    
    // 检查左上到右下对角线
    for (int i = row - 1, j = column - 1; i >= 0 && j >= 0; i--, j--) {
        if (maze[i][j] == 8) {
            return false;
        }
    }
    
    // 检查右上到左下对角线
    for (int i = row - 1, j = column + 1; i >= 0 && j < 8; i--, j++) {
        if (maze[i][j] == 8) {
            return false;
        }
    }
    
	return (row >= 0 && row <= 7) && (column >= 0 && column <= 7) && maze[row][column] == 0;
}

void Application::progress(const Position& p)
{
	if (isValid(p)) maze[p.getRow()][p.getColumn()] = 8; 
}

bool Application::success(const Position& p)
{
	int count = 0;
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            if (maze[i][j] == 8) {
                count++;
            }
        }
    }
    return count == 8;
}

void Application::goBack(const Position& p)
{
	maze[p.getRow()][p.getColumn()] = 0; //available
}

void Application::print()
{
	for (int i = 0; i < 8; i++)
	{
		for (int j = 0; j < 8; j++)
			cout << maze[i][j] << " "; //打印全棋盘
		cout << endl;
	}
}



//======================================================================
struct itrPosition
{
	int row;
	int column;
	int turn; //turn是一个状态码，表示位置状态
};

//application iterator
//对迭代器的无参构造函数 写成NULL
Application::Iterator::Iterator() 
{
	currItrPosPtr = NULL;
}

//对迭代器的有参构造函数
Application::Iterator::Iterator(const Position& currPos)
{
	itrPosition* p = new itrPosition;
	p->row = currPos.getRow();
	p->column = currPos.getColumn();
	p->turn = 0;
	currItrPosPtr = p;
}

Position Application::Iterator::getNextPosition()
{
    itrPosition* p = (itrPosition*)currItrPosPtr;

    if (p->turn == 0) {
        // 第一次调用，返回当前位置
        p->turn = 1;
        return Position(p->row, p->column);
    }
    
    if (p->turn == 1) {
        // 第二次调用，移动到下一行的第一个位置
        p->turn = 2;
        if (p->row < 7) {
            p->row++;
            p->column = 0;
            return Position(p->row, p->column);
        }
    }
    
    if (p->turn == 2 && p->column < 7) {
        // 第三次调用及以后，在当前行内移动
        p->column++;
        return Position(p->row, p->column);
    }
    
    // 如果没有更多位置，仍然返回当前位置
    p->turn = 3;
    return Position(p->row, p->column);
}

bool Application::Iterator::noNextPosition()
{
    itrPosition* p = (itrPosition*)currItrPosPtr;
    
    // 如果已经遍历完所有可能的位置
    if (p->turn >= 3 || (p->row >= 7 && p->column >= 7)) {
        return true;
    }
    
    return false;
}
//析构delete
Application::Iterator::~Iterator()
{
	delete (itrPosition*)currItrPosPtr;
}